home *** CD-ROM | disk | FTP | other *** search
/ LG Super CD / LG Super CD.iso / bitpim / bitpim-0.62-setup.exe / {app} / bitpim.exe / sre_compile.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2003-11-06  |  11.5 KB  |  501 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.3)
  3.  
  4. import _sre
  5. import sys
  6. from sre_constants import *
  7. if _sre.CODESIZE == 2:
  8.     MAXCODE = 65535
  9. else:
  10.     MAXCODE = 0xFFFFFFFFL
  11.  
  12. def _compile(code, pattern, flags):
  13.     emit = code.append
  14.     for op, av in pattern:
  15.         if op in (LITERAL, NOT_LITERAL):
  16.             if flags & SRE_FLAG_IGNORECASE:
  17.                 emit(OPCODES[OP_IGNORE[op]])
  18.                 emit(_sre.getlower(av, flags))
  19.             else:
  20.                 emit(OPCODES[op])
  21.                 emit(av)
  22.         flags & SRE_FLAG_IGNORECASE
  23.         if op is IN:
  24.             if flags & SRE_FLAG_IGNORECASE:
  25.                 emit(OPCODES[OP_IGNORE[op]])
  26.                 
  27.                 def fixup(literal, flags = flags):
  28.                     return _sre.getlower(literal, flags)
  29.  
  30.             else:
  31.                 emit(OPCODES[op])
  32.                 
  33.                 fixup = lambda x: x
  34.             skip = len(code)
  35.             emit(0)
  36.             _compile_charset(av, flags, code, fixup)
  37.             code[skip] = len(code) - skip
  38.             continue
  39.         if op is ANY:
  40.             if flags & SRE_FLAG_DOTALL:
  41.                 emit(OPCODES[ANY_ALL])
  42.             else:
  43.                 emit(OPCODES[ANY])
  44.         flags & SRE_FLAG_DOTALL
  45.         if op in (REPEAT, MIN_REPEAT, MAX_REPEAT):
  46.             if flags & SRE_FLAG_TEMPLATE:
  47.                 raise error, 'internal: unsupported template operator'
  48.                 emit(OPCODES[REPEAT])
  49.                 skip = len(code)
  50.                 emit(0)
  51.                 emit(av[0])
  52.                 emit(av[1])
  53.                 _compile(code, av[2], flags)
  54.                 emit(OPCODES[SUCCESS])
  55.                 code[skip] = len(code) - skip
  56.             elif _simple(av) and op != REPEAT:
  57.                 if op == MAX_REPEAT:
  58.                     emit(OPCODES[REPEAT_ONE])
  59.                 else:
  60.                     emit(OPCODES[MIN_REPEAT_ONE])
  61.                 skip = len(code)
  62.                 emit(0)
  63.                 emit(av[0])
  64.                 emit(av[1])
  65.                 _compile(code, av[2], flags)
  66.                 emit(OPCODES[SUCCESS])
  67.                 code[skip] = len(code) - skip
  68.             else:
  69.                 emit(OPCODES[REPEAT])
  70.                 skip = len(code)
  71.                 emit(0)
  72.                 emit(av[0])
  73.                 emit(av[1])
  74.                 _compile(code, av[2], flags)
  75.                 code[skip] = len(code) - skip
  76.                 if op == MAX_REPEAT:
  77.                     emit(OPCODES[MAX_UNTIL])
  78.                 else:
  79.                     emit(OPCODES[MIN_UNTIL])
  80.         op == MAX_REPEAT
  81.         if op is SUBPATTERN:
  82.             if av[0]:
  83.                 emit(OPCODES[MARK])
  84.                 emit((av[0] - 1) * 2)
  85.             
  86.             _compile(code, av[1], flags)
  87.             if av[0]:
  88.                 emit(OPCODES[MARK])
  89.                 emit((av[0] - 1) * 2 + 1)
  90.             
  91.         av[0]
  92.         if op in (SUCCESS, FAILURE):
  93.             emit(OPCODES[op])
  94.             continue
  95.         if op in (ASSERT, ASSERT_NOT):
  96.             emit(OPCODES[op])
  97.             skip = len(code)
  98.             emit(0)
  99.             if av[0] >= 0:
  100.                 emit(0)
  101.             else:
  102.                 (lo, hi) = av[1].getwidth()
  103.                 if lo != hi:
  104.                     raise error, 'look-behind requires fixed-width pattern'
  105.                 
  106.                 emit(lo)
  107.             _compile(code, av[1], flags)
  108.             emit(OPCODES[SUCCESS])
  109.             code[skip] = len(code) - skip
  110.             continue
  111.         if op is CALL:
  112.             emit(OPCODES[op])
  113.             skip = len(code)
  114.             emit(0)
  115.             _compile(code, av, flags)
  116.             emit(OPCODES[SUCCESS])
  117.             code[skip] = len(code) - skip
  118.             continue
  119.         if op is AT:
  120.             emit(OPCODES[op])
  121.             if flags & SRE_FLAG_MULTILINE:
  122.                 av = AT_MULTILINE.get(av, av)
  123.             
  124.             if flags & SRE_FLAG_LOCALE:
  125.                 av = AT_LOCALE.get(av, av)
  126.             elif flags & SRE_FLAG_UNICODE:
  127.                 av = AT_UNICODE.get(av, av)
  128.             
  129.             emit(ATCODES[av])
  130.             continue
  131.         if op is BRANCH:
  132.             emit(OPCODES[op])
  133.             tail = []
  134.             for av in av[1]:
  135.                 skip = len(code)
  136.                 emit(0)
  137.                 _compile(code, av, flags)
  138.                 emit(OPCODES[JUMP])
  139.                 tail.append(len(code))
  140.                 emit(0)
  141.                 code[skip] = len(code) - skip
  142.             
  143.             emit(0)
  144.             for tail in tail:
  145.                 code[tail] = len(code) - tail
  146.             
  147.         if op is CATEGORY:
  148.             emit(OPCODES[op])
  149.             if flags & SRE_FLAG_LOCALE:
  150.                 av = CH_LOCALE[av]
  151.             elif flags & SRE_FLAG_UNICODE:
  152.                 av = CH_UNICODE[av]
  153.             
  154.             emit(CHCODES[av])
  155.             continue
  156.         if op is GROUPREF:
  157.             if flags & SRE_FLAG_IGNORECASE:
  158.                 emit(OPCODES[OP_IGNORE[op]])
  159.             else:
  160.                 emit(OPCODES[op])
  161.             emit(av - 1)
  162.             continue
  163.         raise ValueError, ('unsupported operand type', op)
  164.     
  165.  
  166.  
  167. def _compile_charset(charset, flags, code, fixup = None):
  168.     emit = code.append
  169.     if fixup is None:
  170.         
  171.         fixup = lambda x: x
  172.     
  173.     for op, av in _optimize_charset(charset, fixup):
  174.         emit(OPCODES[op])
  175.         if op is NEGATE:
  176.             continue
  177.         if op is LITERAL:
  178.             emit(fixup(av))
  179.             continue
  180.         if op is RANGE:
  181.             emit(fixup(av[0]))
  182.             emit(fixup(av[1]))
  183.             continue
  184.         if op is CHARSET:
  185.             code.extend(av)
  186.             continue
  187.         if op is BIGCHARSET:
  188.             code.extend(av)
  189.             continue
  190.         if op is CATEGORY:
  191.             if flags & SRE_FLAG_LOCALE:
  192.                 emit(CHCODES[CH_LOCALE[av]])
  193.             elif flags & SRE_FLAG_UNICODE:
  194.                 emit(CHCODES[CH_UNICODE[av]])
  195.             else:
  196.                 emit(CHCODES[av])
  197.         flags & SRE_FLAG_LOCALE
  198.         raise error, 'internal: unsupported set operator'
  199.     
  200.     emit(OPCODES[FAILURE])
  201.  
  202.  
  203. def _optimize_charset(charset, fixup):
  204.     out = []
  205.     charmap = [
  206.         0] * 256
  207.     
  208.     try:
  209.         for op, av in charset:
  210.             if op is NEGATE:
  211.                 out.append((op, av))
  212.                 continue
  213.             if op is LITERAL:
  214.                 charmap[fixup(av)] = 1
  215.                 continue
  216.             if op is RANGE:
  217.                 for i in range(fixup(av[0]), fixup(av[1]) + 1):
  218.                     charmap[i] = 1
  219.                 
  220.             if op is CATEGORY:
  221.                 return charset
  222.                 continue
  223.     except IndexError:
  224.         return _optimize_unicode(charset, fixup)
  225.  
  226.     i = p = n = 0
  227.     runs = []
  228.     for c in charmap:
  229.         if c:
  230.             if n == 0:
  231.                 p = i
  232.             
  233.             n = n + 1
  234.         elif n:
  235.             runs.append((p, n))
  236.             n = 0
  237.         
  238.         i = i + 1
  239.     
  240.     if n:
  241.         runs.append((p, n))
  242.     
  243.     if len(runs) <= 2:
  244.         for p, n in runs:
  245.             if n == 1:
  246.                 out.append((LITERAL, p))
  247.                 continue
  248.             out.append((RANGE, (p, p + n - 1)))
  249.         
  250.         if len(out) < len(charset):
  251.             return out
  252.         
  253.     else:
  254.         data = _mk_bitmap(charmap)
  255.         out.append((CHARSET, data))
  256.         return out
  257.     return charset
  258.  
  259.  
  260. def _mk_bitmap(bits):
  261.     data = []
  262.     if _sre.CODESIZE == 2:
  263.         start = (1, 0)
  264.     else:
  265.         start = (0x1L, 0x0L)
  266.     (m, v) = start
  267.     for c in bits:
  268.         if c:
  269.             v = v + m
  270.         
  271.         m = m << 1
  272.         if m > MAXCODE:
  273.             data.append(v)
  274.             (m, v) = start
  275.             continue
  276.     
  277.     return data
  278.  
  279.  
  280. def _optimize_unicode(charset, fixup):
  281.     
  282.     try:
  283.         import array
  284.     except ImportError:
  285.         return charset
  286.  
  287.     charmap = [
  288.         0] * 65536
  289.     negate = 0
  290.     
  291.     try:
  292.         for op, av in charset:
  293.             if op is NEGATE:
  294.                 negate = 1
  295.                 continue
  296.             if op is LITERAL:
  297.                 charmap[fixup(av)] = 1
  298.                 continue
  299.             if op is RANGE:
  300.                 for i in range(fixup(av[0]), fixup(av[1]) + 1):
  301.                     charmap[i] = 1
  302.                 
  303.             if op is CATEGORY:
  304.                 return charset
  305.                 continue
  306.     except IndexError:
  307.         return charset
  308.  
  309.     if negate:
  310.         if sys.maxunicode != 65535:
  311.             return charset
  312.         
  313.         for i in range(65536):
  314.             charmap[i] = not charmap[i]
  315.         
  316.     
  317.     comps = { }
  318.     mapping = [
  319.         0] * 256
  320.     block = 0
  321.     data = []
  322.     for i in range(256):
  323.         chunk = tuple(charmap[i * 256:(i + 1) * 256])
  324.         new = comps.setdefault(chunk, block)
  325.         mapping[i] = new
  326.         if new == block:
  327.             block = block + 1
  328.             data = data + _mk_bitmap(chunk)
  329.             continue
  330.     
  331.     header = [
  332.         block]
  333.     if MAXCODE == 65535:
  334.         code = 'H'
  335.     else:
  336.         code = 'L'
  337.     mapping = array.array('b', mapping).tostring()
  338.     header = header + array.array(code, mapping).tolist()
  339.     data[0:0] = header
  340.     return [
  341.         (BIGCHARSET, data)]
  342.  
  343.  
  344. def _simple(av):
  345.     (lo, hi) = av[2].getwidth()
  346.     if lo == 0 and hi == MAXREPEAT:
  347.         raise error, 'nothing to repeat'
  348.     
  349.     if hi == hi:
  350.         pass
  351.     elif hi == 1:
  352.         pass
  353.     return av[2][0][0] != SUBPATTERN
  354.  
  355.  
  356. def _compile_info(code, pattern, flags):
  357.     (lo, hi) = pattern.getwidth()
  358.     if lo == 0:
  359.         return None
  360.     
  361.     prefix = []
  362.     prefix_skip = 0
  363.     charset = []
  364.     if not (flags & SRE_FLAG_IGNORECASE):
  365.         for op, av in pattern.data:
  366.             if op is LITERAL:
  367.                 if len(prefix) == prefix_skip:
  368.                     prefix_skip = prefix_skip + 1
  369.                 
  370.                 prefix.append(av)
  371.                 continue
  372.             if op is SUBPATTERN and len(av[1]) == 1:
  373.                 (op, av) = av[1][0]
  374.                 if op is LITERAL:
  375.                     prefix.append(av)
  376.                 else:
  377.                     break
  378.             op is LITERAL
  379.         
  380.         if not prefix and pattern.data:
  381.             (op, av) = pattern.data[0]
  382.             if op is SUBPATTERN and av[1]:
  383.                 (op, av) = av[1][0]
  384.                 if op is LITERAL:
  385.                     charset.append((op, av))
  386.                 elif op is BRANCH:
  387.                     c = []
  388.                     for p in av[1]:
  389.                         if not p:
  390.                             break
  391.                         
  392.                         (op, av) = p[0]
  393.                         if op is LITERAL:
  394.                             c.append((op, av))
  395.                             continue
  396.                     else:
  397.                         charset = c
  398.                 
  399.             elif op is BRANCH:
  400.                 c = []
  401.                 for p in av[1]:
  402.                     if not p:
  403.                         break
  404.                     
  405.                     (op, av) = p[0]
  406.                     if op is LITERAL:
  407.                         c.append((op, av))
  408.                         continue
  409.                 else:
  410.                     charset = c
  411.             elif op is IN:
  412.                 charset = av
  413.             
  414.         
  415.     
  416.     emit = code.append
  417.     emit(OPCODES[INFO])
  418.     skip = len(code)
  419.     emit(0)
  420.     mask = 0
  421.     if prefix:
  422.         mask = SRE_INFO_PREFIX
  423.         if prefix_skip == prefix_skip:
  424.             pass
  425.         elif prefix_skip == len(pattern.data):
  426.             mask = mask + SRE_INFO_LITERAL
  427.         
  428.     elif charset:
  429.         mask = mask + SRE_INFO_CHARSET
  430.     
  431.     emit(mask)
  432.     if lo < MAXCODE:
  433.         emit(lo)
  434.     else:
  435.         emit(MAXCODE)
  436.         prefix = prefix[:MAXCODE]
  437.     if hi < MAXCODE:
  438.         emit(hi)
  439.     else:
  440.         emit(0)
  441.     if prefix:
  442.         emit(len(prefix))
  443.         emit(prefix_skip)
  444.         code.extend(prefix)
  445.         table = [
  446.             -1] + [
  447.             0] * len(prefix)
  448.         for i in range(len(prefix)):
  449.             table[i + 1] = table[i] + 1
  450.             while table[i + 1] > 0 and prefix[i] != prefix[table[i + 1] - 1]:
  451.                 table[i + 1] = table[table[i + 1] - 1] + 1
  452.         
  453.         code.extend(table[1:])
  454.     elif charset:
  455.         _compile_charset(charset, flags, code)
  456.     
  457.     code[skip] = len(code) - skip
  458.  
  459.  
  460. try:
  461.     unicode
  462. except NameError:
  463.     STRING_TYPES = (type(''),)
  464.  
  465. STRING_TYPES = (type(''), type(unicode('')))
  466.  
  467. def isstring(obj):
  468.     for tp in STRING_TYPES:
  469.         if isinstance(obj, tp):
  470.             return 1
  471.             continue
  472.     
  473.     return 0
  474.  
  475.  
  476. def _code(p, flags):
  477.     flags = p.pattern.flags | flags
  478.     code = []
  479.     _compile_info(code, p, flags)
  480.     _compile(code, p.data, flags)
  481.     code.append(OPCODES[SUCCESS])
  482.     return code
  483.  
  484.  
  485. def compile(p, flags = 0):
  486.     if isstring(p):
  487.         import sre_parse
  488.         pattern = p
  489.         p = sre_parse.parse(p, flags)
  490.     else:
  491.         pattern = None
  492.     code = _code(p, flags)
  493.     groupindex = p.pattern.groupdict
  494.     indexgroup = [
  495.         None] * p.pattern.groups
  496.     for k, i in groupindex.items():
  497.         indexgroup[i] = k
  498.     
  499.     return _sre.compile(pattern, flags, code, p.pattern.groups - 1, groupindex, indexgroup)
  500.  
  501.